home *** CD-ROM | disk | FTP | other *** search
/ MacHack 2001 / MacHack 2001.toast / pc / The Hacks / NotEnoughSecrets / Secret About Box PB / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-06-23  |  8.0 KB  |  356 lines
  1. #include <stdlib.h>
  2. #include <math.h>
  3.  
  4. #include <Carbon/Carbon.h>
  5.  
  6. void SetRandomBackColor();
  7. void CenterWindow(Rect* theRect);
  8. void StartBoard(WindowRef theWindow);
  9. void HandlePaddle();
  10. void HandleBall();
  11. short TheStringWidth(Str255 theString);
  12.  
  13. double gBallVelX;
  14. double gBallVelY;
  15.  
  16. double gBallPosX;
  17. double gBallPosY;
  18.  
  19. Rect *gWords;
  20. short gNumWords=0;
  21.  
  22.  
  23.  
  24. Rect gPaddleRect;
  25.  
  26. short gPaddleVel;
  27.  
  28. void main()
  29. { 
  30.     WindowRef theWindow;
  31.     Rect windowRect={0,0,300,400};
  32.     long t;
  33.     EventRecord theEvent;
  34.     
  35.     gBallPosX = 100;
  36.     gBallPosY = 250;
  37.     gBallVelX = 1.1;
  38.     gBallVelY = -2.4;
  39.     
  40.     CenterWindow(&windowRect);
  41.     
  42.     theWindow = NewWindow(0,&windowRect,"\p",true,1,(WindowRef)-1L,0,0);
  43.     SetQDGlobalsRandomSeed(TickCount());
  44.         
  45.     StartBoard(theWindow);
  46.     
  47.     ForeColor(blackColor);
  48.     BackColor(whiteColor);
  49.     
  50.     while (!Button())
  51.     {
  52.         t = TickCount();
  53.     
  54.         HandlePaddle();
  55.         HandleBall();
  56.         
  57.         while (t==TickCount())
  58.         {
  59.             WaitNextEvent(everyEvent,&theEvent,1,0);
  60.         }
  61.     }
  62.     DisposeWindow(theWindow);
  63.     DisposePtr((Ptr)gWords);
  64.         
  65. }
  66.  
  67.  
  68. void SetRandomBackColor()
  69. {
  70.     switch (abs(Random())%7)
  71.     {
  72.         case 0:
  73.             BackColor(blackColor);
  74.             break;
  75.         case 1:
  76.             BackColor(redColor);
  77.             break;
  78.         case 2:
  79.             BackColor(greenColor);
  80.             break;
  81.         case 3:
  82.             BackColor(blueColor);
  83.             break;
  84.         case 4:
  85.             BackColor(cyanColor);
  86.             break;
  87.         case 5:
  88.             BackColor(magentaColor);
  89.             break;
  90.         case 6:
  91.             BackColor(yellowColor);
  92.             break;
  93.     }
  94. }
  95.  
  96. void CenterWindow(Rect* theRect)
  97. {
  98.     GrafPtr thePort;
  99.     Rect screenRect;
  100.     short    leftPos,topPos,rectWidth,rectHeight;
  101.     
  102.     GetPort(&thePort);
  103.     GetPortBounds(thePort,&screenRect);
  104.  
  105.     leftPos = ((screenRect.right - screenRect.left) - (theRect->right - 
  106.                 theRect->left)) / 2;
  107.     topPos = ((screenRect.bottom - screenRect.top) 
  108.                 - (theRect->bottom - theRect->top))/2;
  109.  
  110.     rectWidth = theRect->right - theRect->left;
  111.     rectHeight = theRect->bottom - theRect->top;
  112.     
  113.     theRect->top = topPos;
  114.     theRect->bottom = theRect->top + rectHeight;
  115.     theRect->left = leftPos;
  116.     theRect->right = theRect->left + rectWidth;
  117. }
  118.  
  119. void StartBoard(WindowRef theWindow)
  120. {
  121.     Rect windowRect;
  122.     FontInfo fInfo;
  123.     Handle rHandle;
  124.     short numStrings;
  125.     Str255 theString;
  126.     Str255 wordString;
  127.     short cursor,oldCursor;
  128.     short vPos,a;
  129.     Rect blockRect;
  130.     char *stringsUsed;
  131.         short stringToUse;
  132.     short stringsToUseOnLine[8];
  133.         short stringsToUseOnLineIndex;
  134.     short lineWidth;
  135.         float bufferPixels;
  136.         
  137.     rHandle = GetResource('STR#',128);
  138.     if (!rHandle)
  139.         ExitToShell();
  140.         
  141.     BlockMove(*rHandle,&numStrings,sizeof(short));
  142.     ReleaseResource (rHandle);
  143.     
  144.     HideCursor();
  145.     
  146.     stringsUsed = NewPtr(numStrings);
  147.     
  148.     for  (a=0;a<numStrings;a++)
  149.         stringsUsed[a]=0;
  150.     
  151.     SetPort(GetWindowPort(theWindow));
  152.     GetPortBounds(GetWindowPort(theWindow),&windowRect);
  153.     
  154.     OffsetRect(&windowRect,-windowRect.left,-windowRect.top);
  155.     
  156.     ForeColor(whiteColor);
  157.     TextSize(10);
  158.     TextFace(bold);
  159.     GetFontInfo(&fInfo);
  160.     
  161.     blockRect.left = 0;
  162.     blockRect.right = 0;
  163.     vPos = 40;
  164.     lineWidth=0;
  165.         stringsToUseOnLineIndex=0;
  166.         
  167.     gWords = (Rect*)NewPtr(sizeof(Rect)*500);  //Hack, but it should be enough
  168.     
  169.     while (vPos<12*8+40)
  170.     {
  171.         while(1)
  172.                 {
  173.                     do {
  174.                         stringToUse = abs(Random())%numStrings;
  175.                     }while(stringsUsed[stringToUse]);
  176.                     
  177.                     
  178.                     GetIndString(theString,128,stringToUse);
  179.                     
  180.                     if (TheStringWidth(theString)+lineWidth<400)
  181.                     {
  182.                         lineWidth+=TheStringWidth(theString);
  183.                         stringsToUseOnLine[stringsToUseOnLineIndex] = stringToUse;
  184.                         stringsToUseOnLineIndex++;
  185.                         stringsUsed[stringToUse]=1;
  186.                     }
  187.                     else
  188.                         break;
  189.                 }
  190.                 bufferPixels = (400-lineWidth)/(stringsToUseOnLineIndex-1);
  191.                 
  192.                 for (a=0;a<stringsToUseOnLineIndex;a++)
  193.                 {
  194.                     SetRandomBackColor();
  195.                     
  196.                     cursor = 0;
  197.                     oldCursor = 1;
  198.                     
  199.                     GetIndString(theString,128,stringsToUseOnLine[a]);
  200.                     
  201.                     while (cursor<=theString[0])
  202.                     {
  203.                             for (cursor=oldCursor;theString[cursor]!=' ' && cursor<=theString[0];cursor++)
  204.                                     ;
  205.                             
  206.                             BlockMove(&(theString[oldCursor]),&(wordString[1]),cursor-oldCursor);
  207.                             wordString[0] = (char)((char)cursor-(char)oldCursor);
  208.                             
  209.                             blockRect.top=vPos-fInfo.ascent-fInfo.descent;
  210.                             blockRect.bottom = vPos;
  211.                             if (blockRect.right)
  212.                                 blockRect.left = blockRect.right+2;
  213.                             blockRect.right = StringWidth(wordString)+blockRect.left;
  214.                             
  215.                             gWords[gNumWords] = blockRect;
  216.                             gNumWords++;
  217.                             
  218.                             MoveTo(blockRect.left,vPos-fInfo.descent);
  219.                             EraseRect(&blockRect);
  220.                             DrawString(wordString);
  221.                             
  222.                             oldCursor = cursor+1;
  223.                     }
  224.                     blockRect.right+=bufferPixels;
  225.                 }
  226.         
  227.                 blockRect.right=0;
  228.                 blockRect.left=2;
  229.                 vPos+=16;
  230.                 lineWidth=0;
  231.                 stringsToUseOnLineIndex=0;
  232.     }
  233.     
  234.     ShowCursor();
  235.     
  236.     //gNumWords--;
  237.     DisposePtr(stringsUsed);
  238. }
  239.  
  240. void HandlePaddle()
  241. {
  242.     Point mouseLoc;
  243.     static Rect oldPaddleRect;
  244.     Rect removeRect;
  245.     
  246.     //Handle Paddle
  247.     GetMouse(&mouseLoc);
  248.     
  249.     if (mouseLoc.h<0)
  250.         gPaddleRect.left = 0;
  251.     else
  252.         gPaddleRect.left = mouseLoc.h;
  253.     
  254.     gPaddleRect.right = gPaddleRect.left+25;
  255.     if (gPaddleRect.right>400)
  256.     {
  257.         gPaddleRect.right = 400;
  258.         gPaddleRect.left = 370;
  259.     }
  260.     gPaddleRect.top = 300-32;
  261.     gPaddleRect.bottom = gPaddleRect.top+4;
  262.     
  263.     PaintRect(&gPaddleRect);
  264.     
  265.     gPaddleVel = gPaddleRect.right-oldPaddleRect.right;
  266.     if (gPaddleVel>5)
  267.         gPaddleVel=5;
  268.     if (gPaddleVel<-5)
  269.         gPaddleVel=-5;
  270.         
  271.     if (oldPaddleRect.right > gPaddleRect.right)
  272.     {
  273.         removeRect.left = gPaddleRect.right;
  274.         removeRect.right = oldPaddleRect.right;
  275.     }
  276.     else
  277.     {
  278.         removeRect.left = oldPaddleRect.left;
  279.         removeRect.right = gPaddleRect.left;
  280.     }
  281.     removeRect.top = oldPaddleRect.top;
  282.     removeRect.bottom = oldPaddleRect.bottom;    
  283.     
  284.     EraseRect(&removeRect);
  285.     
  286.     oldPaddleRect = gPaddleRect;
  287. }
  288.     
  289. void HandleBall()
  290. {
  291.     Rect ballRect;
  292.     Rect oldBallRect;
  293.     short a;
  294.     
  295.     oldBallRect.left = gBallPosX-3;
  296.     oldBallRect.right = gBallPosX+3;
  297.     oldBallRect.top = gBallPosY-3;
  298.     oldBallRect.bottom = gBallPosY+3;
  299.     
  300.     gBallPosX += gBallVelX;
  301.     gBallPosY += gBallVelY;
  302.     
  303.     ballRect.left = gBallPosX-3;
  304.     ballRect.right = gBallPosX+3;
  305.     ballRect.top = gBallPosY-3;
  306.     ballRect.bottom = gBallPosY+3;
  307.     
  308.     EraseRect(&oldBallRect);
  309.     PaintOval(&ballRect);
  310.     
  311.     for (a=0;a<gNumWords;a++)
  312.     {
  313.         if (SectRect(&ballRect,&gWords[a],0))
  314.         {
  315.             //Hit a block.  Erase it and bounce the ball
  316.             EraseRect(&gWords[a]);
  317.             
  318.             gWords[a].top=0;
  319.             gWords[a].left=0;
  320.             gWords[a].right=0;
  321.             gWords[a].bottom=0;
  322.             
  323.             gBallVelY =- gBallVelY;
  324.                         break;
  325.         }
  326.     }
  327.     if (SectRect(&gPaddleRect,&ballRect,0))
  328.     {
  329.         //Hit the paddle. bounce the ball
  330.         gBallVelX += (gBallPosX-(gPaddleRect.left+12))/12;
  331.         gBallVelY =- gBallVelY;
  332.     }
  333.     if (ballRect.right>=400 || ballRect.left<=0) //Hit side walls
  334.         gBallVelX =- gBallVelX;
  335.         
  336.     if (ballRect.top<=0)    //Hit top wall
  337.         gBallVelY =- gBallVelY;
  338.     if (ballRect.bottom>=400)
  339.     {
  340.         gBallVelX = ((float)Random()/(float)20000)+2;
  341.         gBallVelY = ((float)Random()/(float)20000)+2;
  342.         gBallPosX = abs(Random())%300;
  343.         gBallPosY = abs(Random())%100+100;
  344.     }
  345. }
  346.  
  347. short TheStringWidth(Str255 theString)
  348. {
  349.     char a;
  350.     short additionalWidth=0;
  351.     
  352.     for (a=0;a<theString[0];a++)
  353.         if (theString[a+1]==' ')
  354.             additionalWidth+=2;
  355.     return StringWidth(theString)+additionalWidth;
  356. }